// #include <GL/glew.h>
// #include <GLFW/glfw3.h>
// #include <GL/GL.h>
// #include <nanovg.h>
// #define NANOVG_GL3_IMPLEMENTATION
// #include <nanovg_gl.h>
// #include <math.h>
// #include <stdio.h>
// #include <string.h>
// #include <iostream>
// #include <vector>
// using namespace std;

// // 全局变量
// static bool is_dragging = false;
// static float first_x_pos = 0.0f;  // 第一条垂直线 x 坐标
// static float second_x_pos = 0.0f; // 第二条垂直线 x 坐标

// // 鼠标是否悬停在红色区域
// static bool is_hovering_red_area = false;

// // 绘制正弦波数据
// void generateSineWave(float *xs, float *ys, int count, float amplitude, float frequency)
// {
//     for (int i = 0; i < count; ++i)
//     {
//         xs[i] = i * 0.1f;
//         ys[i] = amplitude * sin(frequency * xs[i]);
//     }
// }

// // 手动绘制虚线（替代 nvgStrokeDashArray）
// void drawDashedLine(NVGcontext *vg, float x1, float y1, float x2, float y2, float dashLength, float gapLength)
// {
//     float dx = x2 - x1;
//     float dy = y2 - y1;
//     float length = sqrtf(dx * dx + dy * dy);
//     float dashCount = length / (dashLength + gapLength);

//     nvgBeginPath(vg);
//     for (float i = 0; i < dashCount; i++)
//     {
//         float start = i * (dashLength + gapLength);
//         float end = start + dashLength;
//         if (end > length)
//             end = length;

//         float sx = x1 + (dx / length) * start;
//         float sy = y1 + (dy / length) * start;
//         float ex = x1 + (dx / length) * end;
//         float ey = y1 + (dy / length) * end;

//         nvgMoveTo(vg, sx, sy);
//         nvgLineTo(vg, ex, ey);
//     }
//     nvgStrokeColor(vg, nvgRGBA(255, 255, 255, 255));
//     nvgStrokeWidth(vg, 1.0f);
//     nvgStroke(vg);
// }

// // 绘制刻度线和标签
// void drawAxisTicks(NVGcontext* vg, float x, float y, float length, int count, float step, bool isVertical)
// {
//     nvgStrokeColor(vg, nvgRGBA(100, 100, 100, 255));
//     nvgStrokeWidth(vg, 1.0f);
    
//     float start = isVertical ? y - length : x - length;
//     float end = isVertical ? y + length : x + length;
    
//     // 绘制刻度线
//     for (int i = 0; i <= count; i++)
//     {
//         float pos = isVertical ? y - (i * step) : x + (i * step);
//         if (isVertical)
//         {
//             nvgBeginPath(vg);
//             nvgMoveTo(vg, x - 5, pos);
//             nvgLineTo(vg, x + 5, pos);
//             nvgStroke(vg);
            
//             // 绘制刻度值
//             char label[16];
//             snprintf(label, sizeof(label), "%.1f", i * step);
//             nvgFontSize(vg, 10.0f);
//             nvgFontFace(vg, "sans");
//             nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
//             nvgFillColor(vg, nvgRGBA(200, 200, 200, 255));
//             nvgText(vg, x - 10, pos, label, NULL);
//         }
//         else
//         {
//             nvgBeginPath(vg);
//             nvgMoveTo(vg, pos, y - 5);
//             nvgLineTo(vg, pos, y + 5);
//             nvgStroke(vg);
            
//             // 绘制刻度值
//             char label[16];
//             snprintf(label, sizeof(label), "%.1f", i * step);
//             nvgFontSize(vg, 10.0f);
//             nvgFontFace(vg, "sans");
//             nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
//             nvgFillColor(vg, nvgRGBA(200, 200, 200, 255));
//             nvgText(vg, pos, y + 10, label, NULL);
//         }
//     }
// }

// // 主函数
// int main()
// {
//     // 初始化 GLFW
//     if (!glfwInit())
//     {
//         fprintf(stderr, "Failed to initialize GLFW\n");
//         return -1;
//     }

//     // 创建窗口
//     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
//     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
//     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
//     GLFWwindow *window = glfwCreateWindow(800, 600, "NanoVG Plot with Dragging Lines", NULL, NULL);
//     if (!window)
//     {
//         fprintf(stderr, "Failed to create GLFW window\n");
//         glfwTerminate();
//         return -1;
//     }
//     glfwMakeContextCurrent(window);
//     // 初始化 GLEW
//     if (glewInit() != GLEW_OK)
//     {
//         std::cerr << "Failed to initialize GLEW" << std::endl;
//         glfwTerminate();
//         return -1;
//     }
//     // 初始化 NanoVG
//     NVGcontext *vg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES);
//     if (vg == NULL)
//     {
//         fprintf(stderr, "Could not init nanovg.\n");
//         return -1;
//     }

//     // 生成正弦波数据
//     const int point_count = 100;
//     float xs[point_count], ys[point_count];
//     generateSineWave(xs, ys, point_count, 1.0f, 1.0f);
    
//     // 加载字体
//     int fontNormal = nvgCreateFont(vg, "sans", "C:/Users/free/Downloads/OpenGLProject/OffScreen/Roboto-Bold.ttf");
//     if (fontNormal == -1)
//     {
//         printf("Error: Could not load font 'arial.ttf'\n");
//         // 处理错误（如退出程序或使用备用字体）
//     }

//     // 主循环
//     while (!glfwWindowShouldClose(window))
//     {
//         // 处理输入
//         glfwPollEvents();

//         // 获取窗口尺寸
//         int fb_width, fb_height;   // 帧缓冲区大小（像素）
//         int win_width, win_height; // 窗口大小（逻辑像素）

//         glfwGetFramebufferSize(window, &fb_width, &fb_height); // 获取帧缓冲区大小
//         glfwGetWindowSize(window, &win_width, &win_height);    // 获取窗口大小

//         float pixel_ratio = (float)fb_width / (float)win_width; // 计算像素比例

//         // 开始 NanoVG 帧
//         nvgBeginFrame(vg, win_width, win_height, pixel_ratio);

//         // 绘制背景
//         nvgBeginPath(vg);
//         nvgRect(vg, 0, 0, win_width, win_height);
//         nvgFillColor(vg, nvgRGBA(30, 30, 30, 255));
//         nvgFill(vg);

//         // 绘制绘图区域（假设绘图区域占窗口的 80%）
//         float plot_margin = 50.0f;
//         float plot_width = win_width - 2 * plot_margin;
//         float plot_height = win_height - 2 * plot_margin;
//         float plot_x = plot_margin;
//         float plot_y = plot_margin;

//         // 绘制绘图区域背景
//         nvgBeginPath(vg);
//         nvgRect(vg, plot_x, plot_y, plot_width, plot_height);
//         nvgFillColor(vg, nvgRGBA(40, 40, 40, 255));
//         nvgFill(vg);

//         // 计算正弦波的绘制范围
//         float x_min = 0.0f;
//         float x_max = point_count * 0.1f;
//         float y_min = -1.5f;
//         float y_max = 1.5f;

//         // 绘制坐标轴
//         nvgBeginPath(vg);
//         nvgMoveTo(vg, plot_x, plot_y + plot_height / 2);
//         nvgLineTo(vg, plot_x + plot_width, plot_y + plot_height / 2);
//         nvgMoveTo(vg, plot_x + plot_width / 2, plot_y);
//         nvgLineTo(vg, plot_x + plot_width / 2, plot_y + plot_height);
//         nvgStrokeColor(vg, nvgRGBA(100, 100, 100, 255));
//         nvgStrokeWidth(vg, 1.0f);
//         nvgStroke(vg);

//         // 绘制X轴刻度
//         int x_tick_count = 10;
//         float x_step = (x_max - x_min) / x_tick_count;
//         drawAxisTicks(vg, plot_x + plot_width / 2, plot_y + plot_height, 5.0f, x_tick_count, x_step, true);

//         // 绘制Y轴刻度
//         int y_tick_count = 10;
//         float y_step = (y_max - y_min) / y_tick_count;
//         drawAxisTicks(vg, plot_x, plot_y + plot_height / 2, 5.0f, y_tick_count, y_step, false);

//         // 绘制正弦波（限制在绘图区域内）
//         nvgBeginPath(vg);
//         for (int i = 0; i < point_count; ++i)
//         {
//             // 计算绘图坐标
//             float x = plot_x + (xs[i] - x_min) / (x_max - x_min) * plot_width;
//             float y = plot_y + plot_height / 2 - (ys[i] - y_min) / (y_max - y_min) * plot_height;
            
//             // 确保点在绘图区域内
//             x = fmaxf(plot_x, fminf(x, plot_x + plot_width));
//             y = fmaxf(plot_y, fminf(y, plot_y + plot_height));
            
//             if (i == 0)
//             {
//                 nvgMoveTo(vg, x, y);
//             }
//             else
//             {
//                 nvgLineTo(vg, x, y);
//             }
//         }
//         nvgStrokeColor(vg, nvgRGBA(255, 255, 255, 255));
//         nvgStrokeWidth(vg, 2.0f);
//         nvgStroke(vg);

//         // 鼠标交互逻辑
//         double mouse_x, mouse_y;
//         glfwGetCursorPos(window, &mouse_x, &mouse_y);
//         float mouse_x_in_plot = (mouse_x - plot_x) / plot_width * (x_max - x_min) + x_min;
//         float mouse_y_in_plot = (plot_y + plot_height - mouse_y) / plot_height * (y_max - y_min) + y_min;

//         // 检测鼠标是否悬停在红色区域
//         if (is_dragging || second_x_pos != 0.0f)
//         {
//             float x1 = first_x_pos;
//             float x2 = second_x_pos;
//             float vx1 = plot_x + (x1 - x_min) / (x_max - x_min) * plot_width;
//             float vx2 = plot_x + (x2 - x_min) / (x_max - x_min) * plot_width;

//             // 检查鼠标是否在红色区域内
//             if (mouse_x >= vx1 && mouse_x <= vx2 && mouse_y >= plot_y && mouse_y <= plot_y + plot_height)
//             {
//                 is_hovering_red_area = true;
//             }
//             else
//             {
//                 is_hovering_red_area = false;
//             }
//         }
//         else
//         {
//             is_hovering_red_area = false;
//         }

//         // 根据悬停状态选择填充颜色
//         NVGcolor fill_color;
//         if (is_hovering_red_area)
//         {
//             fill_color = nvgRGBA(255, 0, 0, 64); // 更亮的红色（更低透明度）
//         }
//         else
//         {
//             fill_color = nvgRGBA(255, 0, 0, 128); // 默认半透明红色
//         }

//         if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
//         {
//             if (!is_dragging)
//             {
//                 // 鼠标按下时，记录第一条垂直线
//                 first_x_pos = mouse_x_in_plot;
//                 is_dragging = true;
//             }
//             else
//             {
//                 // 鼠标拖动时，更新第二条垂直线
//                 second_x_pos = mouse_x_in_plot;
//             }
//         }
//         else
//         {
//             if (is_dragging)
//             {
//                 // 鼠标释放时，固定第二条垂直线
//                 second_x_pos = mouse_x_in_plot;
//                 is_dragging = false;
//             }
//         }

//         // 绘制两条垂直虚线（如果正在拖动或已经释放）
//         if (is_dragging || second_x_pos != 0.0f)
//         {
//             // 第一条垂直线（固定）
//             float x1 = first_x_pos;
//             float vx1 = plot_x + (x1 - x_min) / (x_max - x_min) * plot_width;
//             drawDashedLine(vg, vx1, plot_y, vx1, plot_y + plot_height, 5.0f, 5.0f); // 5px 实线 + 5px 空白

//             // 第二条垂直线（动态）
//             float x2 = second_x_pos;
//             float vx2 = plot_x + (x2 - x_min) / (x_max - x_min) * plot_width;
//             drawDashedLine(vg, vx2, plot_y, vx2, plot_y + plot_height, 5.0f, 5.0f); // 5px 实线 + 5px 空白

//             // 半透明红色填充（根据悬停状态调整透明度）
//             nvgBeginPath(vg);
//             nvgRect(vg, vx1, plot_y, vx2 - vx1, plot_height);
//             nvgFillColor(vg, fill_color);
//             nvgFill(vg);

//             // 水平虚线（两条垂直线之间的中点）
//             float y_mid = plot_y + plot_height / 2;
//             drawDashedLine(vg, vx1, y_mid, vx2, y_mid, 1.0f, 1.0f); // 1px 实线 + 1px 空白

//             // 绘制箭头（简化版，用三角形模拟）
//             float arrow_size = 5.0f;
//             // 左侧箭头
//             nvgBeginPath(vg);
//             nvgMoveTo(vg, vx1, y_mid - arrow_size);
//             nvgLineTo(vg, vx1, y_mid + arrow_size);
//             nvgLineTo(vg, vx1 + arrow_size, y_mid);
//             nvgClosePath(vg);
//             nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
//             nvgFill(vg);

//             // 右侧箭头
//             nvgBeginPath(vg);
//             nvgMoveTo(vg, vx2, y_mid - arrow_size);
//             nvgLineTo(vg, vx2, y_mid + arrow_size);
//             nvgLineTo(vg, vx2 - arrow_size, y_mid);
//             nvgClosePath(vg);
//             nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
//             nvgFill(vg);

//             // 显示距离值
//             float distance = x2 - x1;
//             char distance_text[32];
//             snprintf(distance_text, sizeof(distance_text), "%.2f", distance);
//             nvgFontSize(vg, 12.0f);
//             nvgFontFace(vg, "sans");
//             nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
//             nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
//             nvgText(vg, (vx1 + vx2) / 2, y_mid, distance_text, NULL);
//         }

//         // 结束 NanoVG 帧
//         nvgEndFrame(vg);

//         // 交换缓冲区
//         glfwSwapBuffers(window);
//     }

//     // 清理资源
//     nvgDeleteGL3(vg);
//     glfwDestroyWindow(window);
//     glfwTerminate();

//     return 0;
// }


/***************************************************************************************************************************************
///////////////////////////////////////////////-sine wave data dynamiclly with time ...///////////////////////////////////////////////////
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <GL/GL.h>
#include <nanovg.h>
#define NANOVG_GL3_IMPLEMENTATION
#include <nanovg_gl.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
using namespace std;

// 全局变量
static bool is_dragging = false;
static float first_x_pos = 0.0f;  // 第一条垂直线 x 坐标
static float second_x_pos = 0.0f; // 第二条垂直线 x 坐标

// 鼠标是否悬停在红色区域
static bool is_hovering_red_area = false;

// 动态波形数据
float* xs = nullptr;  // x坐标数组
float* ys = nullptr;  // y坐标数组
int point_count = 100; // 数据点数量
float amplitude = 1.0f; // 振幅
float frequency = 1.0f; // 频率
 float timevar = 0.0f;      // 时间变量

// 生成正弦波数据（带时间变化）
void generateDynamicSineWave(float *xs, float *ys, int count, float amplitude, float frequency, float time)
{
    for (int i = 0; i < count; ++i)
    {
        xs[i] = i * 0.1f;
        // 添加时间变量使波形动态变化
        ys[i] = amplitude * sin(frequency * xs[i] + time);
    }
}

// 手动绘制虚线（替代 nvgStrokeDashArray）
void drawDashedLine(NVGcontext *vg, float x1, float y1, float x2, float y2, float dashLength, float gapLength)
{
    float dx = x2 - x1;
    float dy = y2 - y1;
    float length = sqrtf(dx * dx + dy * dy);
    float dashCount = length / (dashLength + gapLength);

    nvgBeginPath(vg);
    for (float i = 0; i < dashCount; i++)
    {
        float start = i * (dashLength + gapLength);
        float end = start + dashLength;
        if (end > length)
            end = length;

        float sx = x1 + (dx / length) * start;
        float sy = y1 + (dy / length) * start;
        float ex = x1 + (dx / length) * end;
        float ey = y1 + (dy / length) * end;

        nvgMoveTo(vg, sx, sy);
        nvgLineTo(vg, ex, ey);
    }
    nvgStrokeColor(vg, nvgRGBA(255, 255, 255, 255));
    nvgStrokeWidth(vg, 1.0f);
    nvgStroke(vg);
}

// 绘制刻度线和标签
void drawAxisTicks(NVGcontext* vg, float x, float y, float length, int count, float step, bool isVertical)
{
    nvgStrokeColor(vg, nvgRGBA(100, 100, 100, 255));
    nvgStrokeWidth(vg, 1.0f);
    
    float start = isVertical ? y - length : x - length;
    float end = isVertical ? y + length : x + length;
    
    // 绘制刻度线
    for (int i = 0; i <= count; i++)
    {
        float pos = isVertical ? y - (i * step) : x + (i * step);
        if (isVertical)
        {
            nvgBeginPath(vg);
            nvgMoveTo(vg, x - 5, pos);
            nvgLineTo(vg, x + 5, pos);
            nvgStroke(vg);
            
            // 绘制刻度值
            char label[16];
            snprintf(label, sizeof(label), "%.1f", i * step);
            nvgFontSize(vg, 5.0f);
            nvgFontFace(vg, "sans");
            nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
            nvgFillColor(vg, nvgRGBA(200, 200, 200, 255));
            nvgText(vg, x - 10, pos, label, NULL);
        }
        else
        {
            nvgBeginPath(vg);
            nvgMoveTo(vg, pos, y - 5);
            nvgLineTo(vg, pos, y + 5);
            nvgStroke(vg);
            
            // 绘制刻度值
            char label[16];
            snprintf(label, sizeof(label), "%.1f", i * step);
            nvgFontSize(vg, 10.0f);
            nvgFontFace(vg, "sans");
            nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
            nvgFillColor(vg, nvgRGBA(200, 200, 200, 255));
            nvgText(vg, pos, y + 10, label, NULL);
        }
    }
}

// 主函数
int main()
{
    // 初始化 GLFW
    if (!glfwInit())
    {
        fprintf(stderr, "Failed to initialize GLFW\n");
        return -1;
    }

    // 创建窗口
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    GLFWwindow *window = glfwCreateWindow(800, 600, "Dynamic NanoVG Waveform", NULL, NULL);
    if (!window)
    {
        fprintf(stderr, "Failed to create GLFW window\n");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    // 初始化 GLEW
    if (glewInit() != GLEW_OK)
    {
        std::cerr << "Failed to initialize GLEW" << std::endl;
        glfwTerminate();
        return -1;
    }
    // 初始化 NanoVG
    NVGcontext *vg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES);
    if (vg == NULL)
    {
        fprintf(stderr, "Could not init nanovg.\n");
        return -1;
    }

    // 分配内存给波形数据
    xs = new float[point_count];
    ys = new float[point_count];
    
    // 初始生成波形数据
    generateDynamicSineWave(xs, ys, point_count, amplitude, frequency, timevar);
    
    // 加载字体
    int fontNormal = nvgCreateFont(vg, "sans", "C:/Users/free/Downloads/OpenGLProject/OffScreen/Roboto-Bold.ttf");
    if (fontNormal == -1)
    {
        printf("Error: Could not load font 'arial.ttf'\n");
        // 处理错误（如退出程序或使用备用字体）
    }

    // 主循环
    double last_time = glfwGetTime();
    while (!glfwWindowShouldClose(window))
    {
        // 计算时间增量
        double current_time = glfwGetTime();
        float delta_time = (float)(current_time - last_time);
        last_time = current_time;
        
        // 更新时间变量（用于波形动画）
        timevar += delta_time * 0.5f; // 调整这个系数可以改变动画速度

        // 处理输入
        glfwPollEvents();

        // 获取窗口尺寸
        int fb_width, fb_height;   // 帧缓冲区大小（像素）
        int win_width, win_height; // 窗口大小（逻辑像素）

        glfwGetFramebufferSize(window, &fb_width, &fb_height); // 获取帧缓冲区大小
        glfwGetWindowSize(window, &win_width, &win_height);    // 获取窗口大小

        float pixel_ratio = (float)fb_width / (float)win_width; // 计算像素比例

        // 开始 NanoVG 帧
        nvgBeginFrame(vg, win_width, win_height, pixel_ratio);

        // 绘制背景
        nvgBeginPath(vg);
        nvgRect(vg, 0, 0, win_width, win_height);
        nvgFillColor(vg, nvgRGBA(30, 30, 30, 255));
        nvgFill(vg);

        // 绘制绘图区域（假设绘图区域占窗口的 80%）
        float plot_margin = 50.0f;
        float plot_width = win_width - 2 * plot_margin;
        float plot_height = win_height - 2 * plot_margin;
        float plot_x = plot_margin;
        float plot_y = plot_margin;

        // 绘制绘图区域背景
        nvgBeginPath(vg);
        nvgRect(vg, plot_x, plot_y, plot_width, plot_height);
        nvgFillColor(vg, nvgRGBA(40, 40, 40, 255));
        nvgFill(vg);

        // 计算正弦波的绘制范围
        float x_min = 0.0f;
        float x_max = point_count * 0.1f;
        float y_min = -1.5f;
        float y_max = 1.5f;

        // 绘制坐标轴
        nvgBeginPath(vg);
        nvgMoveTo(vg, plot_x, plot_y + plot_height / 2);
        nvgLineTo(vg, plot_x + plot_width, plot_y + plot_height / 2);
        nvgMoveTo(vg, plot_x + plot_width / 2, plot_y);
        nvgLineTo(vg, plot_x + plot_width / 2, plot_y + plot_height);
        nvgStrokeColor(vg, nvgRGBA(100, 100, 100, 255));
        nvgStrokeWidth(vg, 1.0f);
        nvgStroke(vg);

        // 绘制X轴刻度
        int x_tick_count = 10;
        float x_step = (x_max - x_min) / x_tick_count;
        drawAxisTicks(vg, plot_x + plot_width / 2, plot_y + plot_height, 5.0f, x_tick_count, x_step, true);

        // 绘制Y轴刻度
        int y_tick_count = 10;
        float y_step = (y_max - y_min) / y_tick_count;
        drawAxisTicks(vg, plot_x, plot_y + plot_height / 2, 5.0f, y_tick_count, y_step, false);

        // 动态生成波形数据
        generateDynamicSineWave(xs, ys, point_count, amplitude, frequency, timevar);

        // 绘制正弦波（限制在绘图区域内）
        nvgBeginPath(vg);
        for (int i = 0; i < point_count; ++i)
        {
            // 计算绘图坐标
            float x = plot_x + (xs[i] - x_min) / (x_max - x_min) * plot_width;
            float y = plot_y + plot_height / 2 - (ys[i] - y_min) / (y_max - y_min) * plot_height;
            
            // 确保点在绘图区域内
            x = fmaxf(plot_x, fminf(x, plot_x + plot_width));
            y = fmaxf(plot_y, fminf(y, plot_y + plot_height));
            
            if (i == 0)
            {
                nvgMoveTo(vg, x, y);
            }
            else
            {
                nvgLineTo(vg, x, y);
            }
        }
        nvgStrokeColor(vg, nvgRGBA(255, 255, 255, 255));
        nvgStrokeWidth(vg, 2.0f);
        nvgStroke(vg);

        // 鼠标交互逻辑
        double mouse_x, mouse_y;
        glfwGetCursorPos(window, &mouse_x, &mouse_y);
        float mouse_x_in_plot = (mouse_x - plot_x) / plot_width * (x_max - x_min) + x_min;
        float mouse_y_in_plot = (plot_y + plot_height - mouse_y) / plot_height * (y_max - y_min) + y_min;

        // 检测鼠标是否悬停在红色区域
        if (is_dragging || second_x_pos != 0.0f)
        {
            float x1 = first_x_pos;
            float x2 = second_x_pos;
            float vx1 = plot_x + (x1 - x_min) / (x_max - x_min) * plot_width;
            float vx2 = plot_x + (x2 - x_min) / (x_max - x_min) * plot_width;

            // 检查鼠标是否在红色区域内
            if (mouse_x >= vx1 && mouse_x <= vx2 && mouse_y >= plot_y && mouse_y <= plot_y + plot_height)
            {
                is_hovering_red_area = true;
            }
            else
            {
                is_hovering_red_area = false;
            }
        }
        else
        {
            is_hovering_red_area = false;
        }

        // 根据悬停状态选择填充颜色
        NVGcolor fill_color;
        if (is_hovering_red_area)
        {
            fill_color = nvgRGBA(255, 0, 0, 64); // 更亮的红色（更低透明度）
        }
        else
        {
            fill_color = nvgRGBA(255, 0, 0, 128); // 默认半透明红色
        }

        if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
        {
            if (!is_dragging)
            {
                // 鼠标按下时，记录第一条垂直线
                first_x_pos = mouse_x_in_plot;
                is_dragging = true;
            }
            else
            {
                // 鼠标拖动时，更新第二条垂直线
                second_x_pos = mouse_x_in_plot;
            }
        }
        else
        {
            if (is_dragging)
            {
                // 鼠标释放时，固定第二条垂直线
                second_x_pos = mouse_x_in_plot;
                is_dragging = false;
            }
        }

        // 绘制两条垂直虚线（如果正在拖动或已经释放）
        if (is_dragging || second_x_pos != 0.0f)
        {
            // 第一条垂直线（固定）
            float x1 = first_x_pos;
            float vx1 = plot_x + (x1 - x_min) / (x_max - x_min) * plot_width;
            drawDashedLine(vg, vx1, plot_y, vx1, plot_y + plot_height, 5.0f, 5.0f); // 5px 实线 + 5px 空白

            // 第二条垂直线（动态）
            float x2 = second_x_pos;
            float vx2 = plot_x + (x2 - x_min) / (x_max - x_min) * plot_width;
            drawDashedLine(vg, vx2, plot_y, vx2, plot_y + plot_height, 5.0f, 5.0f); // 5px 实线 + 5px 空白

            // 半透明红色填充（根据悬停状态调整透明度）
            nvgBeginPath(vg);
            nvgRect(vg, vx1, plot_y, vx2 - vx1, plot_height);
            nvgFillColor(vg, fill_color);
            nvgFill(vg);

            // 水平虚线（两条垂直线之间的中点）
            float y_mid = plot_y + plot_height / 2;
            drawDashedLine(vg, vx1, y_mid, vx2, y_mid, 1.0f, 1.0f); // 1px 实线 + 1px 空白

            // 绘制箭头（简化版，用三角形模拟）
            float arrow_size = 5.0f;
            // 左侧箭头
            nvgBeginPath(vg);
            nvgMoveTo(vg, vx1, y_mid - arrow_size);
            nvgLineTo(vg, vx1, y_mid + arrow_size);
            nvgLineTo(vg, vx1 + arrow_size, y_mid);
            nvgClosePath(vg);
            nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
            nvgFill(vg);

            // 右侧箭头
            nvgBeginPath(vg);
            nvgMoveTo(vg, vx2, y_mid - arrow_size);
            nvgLineTo(vg, vx2, y_mid + arrow_size);
            nvgLineTo(vg, vx2 - arrow_size, y_mid);
            nvgClosePath(vg);
            nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
            nvgFill(vg);

            // 显示距离值
            float distance = x2 - x1;
            char distance_text[32];
            snprintf(distance_text, sizeof(distance_text), "%.2f", distance);
            nvgFontSize(vg, 12.0f);
            nvgFontFace(vg, "sans");
            nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
            nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
            nvgText(vg, (vx1 + vx2) / 2, y_mid, distance_text, NULL);
        }

        // 结束 NanoVG 帧
        nvgEndFrame(vg);

        // 交换缓冲区
        glfwSwapBuffers(window);
    }

    // 清理资源
    delete[] xs;
    delete[] ys;
    nvgDeleteGL3(vg);
    glfwDestroyWindow(window);
    glfwTerminate();

    return 0;
}
********************************************************************************************************************************************/




//  #include <GL/glew.h>
// #include <GLFW/glfw3.h>
// #include <GL/GL.h>
// #include <nanovg.h>
// #define NANOVG_GL3_IMPLEMENTATION
// #include <nanovg_gl.h>
// #include <math.h>
// #include <stdio.h>
// #include <string.h>
// #include <iostream>
// #include <vector>
// using namespace std;

// // 全局变量
// static bool is_dragging = false;
// static float first_x_pos = 0.0f;  // 第一条垂直线 x 坐标
// static float second_x_pos = 0.0f; // 第二条垂直线 x 坐标

// // 鼠标是否悬停在红色区域
// static bool is_hovering_red_area = false;

// // 绘制正弦波数据
// void generateSineWave(float *xs, float *ys, int count, float amplitude, float frequency)
// {
//     for (int i = 0; i < count; ++i)
//     {
//         xs[i] = i * 0.1f;
//         ys[i] = amplitude * sin(frequency * xs[i]);
//     }
// }

// // 手动绘制虚线(替代 nvgStrokeDashArray)
// void drawDashedLine(NVGcontext *vg, float x1, float y1, float x2, float y2, float dashLength, float gapLength)
// {
//     float dx = x2 - x1;
//     float dy = y2 - y1;
//     float length = sqrtf(dx * dx + dy * dy);
//     if (length == 0) return; // 避免除以零
//     float dashCount = length / (dashLength + gapLength);

//     nvgBeginPath(vg);
//     for (float i = 0; i < dashCount; i++)
//     {
//         float start = i * (dashLength + gapLength);
//         float end = start + dashLength;
//         if (end > length)
//             end = length;

//         float sx = x1 + (dx / length) * start;
//         float sy = y1 + (dy / length) * start;
//         float ex = x1 + (dx / length) * end;
//         float ey = y1 + (dy / length) * end;

//         nvgMoveTo(vg, sx, sy);
//         nvgLineTo(vg, ex, ey);
//     }
//     nvgStrokeColor(vg, nvgRGBA(255, 255, 255, 255));
//     nvgStrokeWidth(vg, 1.0f);
//     nvgStroke(vg);
// }

// // 绘制刻度线和标签
// void drawAxisTicks(NVGcontext* vg, float x, float y, float length, int count, float step, bool isVertical)
// {
//     nvgStrokeColor(vg, nvgRGBA(100, 100, 100, 255));
//     nvgStrokeWidth(vg, 1.0f);
    
//     float start = isVertical ? y - length : x - length;
//     float end = isVertical ? y + length : x + length;
    
//     // 绘制刻度线
//     for (int i = 0; i <= count; i++)
//     {
//         float pos = isVertical ? y - (i * step) : x + (i * step);
//         if (isVertical)
//         {
//             nvgBeginPath(vg);
//             nvgMoveTo(vg, x - 5, pos);
//             nvgLineTo(vg, x + 5, pos);
//             nvgStroke(vg);
            
//             // 绘制刻度值
//             char label[16];
//             snprintf(label, sizeof(label), "%.1f", i * step);
//             nvgFontSize(vg, 10.0f);
//             nvgFontFace(vg, "sans");
//             nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
//             nvgFillColor(vg, nvgRGBA(200, 200, 200, 255));
//             nvgText(vg, x - 10, pos, label, NULL);
//         }
//         else
//         {
//             nvgBeginPath(vg);
//             nvgMoveTo(vg, pos, y - 5);
//             nvgLineTo(vg, pos, y + 5);
//             nvgStroke(vg);
            
//             // 绘制刻度值
//             char label[16];
//             snprintf(label, sizeof(label), "%.1f", i * step);
//             nvgFontSize(vg, 10.0f);
//             nvgFontFace(vg, "sans");
//             nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
//             nvgFillColor(vg, nvgRGBA(200, 200, 200, 255));
//             nvgText(vg, pos, y + 10, label, NULL);
//         }
//     }
// }

// // 主函数
// int main()
// {
//     // 初始化 GLFW
//     if (!glfwInit())
//     {
//         fprintf(stderr, "Failed to initialize GLFW\n");
//         return -1;
//     }

//     // 创建窗口
//     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
//     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
//     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
//     GLFWwindow *window = glfwCreateWindow(800, 600, "NanoVG Plot with Dragging Lines", NULL, NULL);
//     if (!window)
//     {
//         fprintf(stderr, "Failed to create GLFW window\n");
//         glfwTerminate();
//         return -1;
//     }
//     glfwMakeContextCurrent(window);
//     // 初始化 GLEW
//     if (glewInit() != GLEW_OK)
//     {
//         std::cerr << "Failed to initialize GLEW" << std::endl;
//         glfwTerminate();
//         return -1;
//     }
//     // 初始化 NanoVG
//     NVGcontext *vg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES);
//     if (vg == NULL)
//     {
//         fprintf(stderr, "Could not init nanovg.\n");
//         return -1;
//     }

//     // 生成正弦波数据
//     const int point_count = 100;
//     float xs[point_count], ys[point_count];
//     generateSineWave(xs, ys, point_count, 1.0f, 1.0f);
    
//     // 加载字体
//     int fontNormal = nvgCreateFont(vg, "sans", "C:/Users/free/Downloads/OpenGLProject/OffScreen/Roboto-Bold.ttf");
//     if (fontNormal == -1)
//     {
//         printf("Error: Could not load font 'Roboto-Bold.ttf'\n");
//         // 处理错误(如退出程序或使用备用字体)
//     }

//     // 主循环
//     while (!glfwWindowShouldClose(window))
//     {
//         // 处理输入
//         glfwPollEvents();

//         // 获取窗口尺寸
//         int fb_width, fb_height;   // 帧缓冲区大小(像素)
//         int win_width, win_height; // 窗口大小(逻辑像素)

//         glfwGetFramebufferSize(window, &fb_width, &fb_height); // 获取帧缓冲区大小
//         glfwGetWindowSize(window, &win_width, &win_height);    // 获取窗口大小

//         float pixel_ratio = (float)fb_width / (float)win_width; // 计算像素比例

//         // 开始 NanoVG 帧
//         nvgBeginFrame(vg, win_width, win_height, pixel_ratio);

//         // 绘制背景
//         nvgBeginPath(vg);
//         nvgRect(vg, 0, 0, win_width, win_height);
//         nvgFillColor(vg, nvgRGBA(30, 30, 30, 255));
//         nvgFill(vg);

//         // 绘制绘图区域(假设绘图区域占窗口的80%)
//         float plot_margin = 50.0f;
//         float plot_width = win_width - 2 * plot_margin;
//         float plot_height = win_height - 2 * plot_margin;
//         float plot_x = plot_margin;
//         float plot_y = plot_margin;

//         // 绘制绘图区域背景
//         nvgBeginPath(vg);
//         nvgRect(vg, plot_x, plot_y, plot_width, plot_height);
//         nvgFillColor(vg, nvgRGBA(40, 40, 40, 255));
//         nvgFill(vg);

//         // 计算正弦波的绘制范围
//         float x_min = 0.0f;
//         float x_max = point_count * 0.1f;
//         float y_min = -1.5f;
//         float y_max = 1.5f;

//         // 绘制坐标轴
//         nvgBeginPath(vg);
//         nvgMoveTo(vg, plot_x, plot_y + plot_height / 2);
//         nvgLineTo(vg, plot_x + plot_width, plot_y + plot_height / 2);
//         nvgMoveTo(vg, plot_x + plot_width / 2, plot_y);
//         nvgLineTo(vg, plot_x + plot_width / 2, plot_y + plot_height);
//         nvgStrokeColor(vg, nvgRGBA(100, 100, 100, 255));
//         nvgStrokeWidth(vg, 1.0f);
//         nvgStroke(vg);

//         // 绘制X轴刻度
//         int x_tick_count = 10;
//         float x_step = (x_max - x_min) / x_tick_count;
//         drawAxisTicks(vg, plot_x + plot_width / 2, plot_y + plot_height, 5.0f, x_tick_count, x_step, true);

//         // 绘制Y轴刻度
//         int y_tick_count = 10;
//         float y_step = (y_max - y_min) / y_tick_count;
//         drawAxisTicks(vg, plot_x, plot_y + plot_height / 2, 5.0f, y_tick_count, y_step, false);

//         // 鼠标交互逻辑
//         double mouse_x, mouse_y;
//         glfwGetCursorPos(window, &mouse_x, &mouse_y);
//         float mouse_x_in_plot = (mouse_x - plot_x) / plot_width * (x_max - x_min) + x_min;
//         float mouse_y_in_plot = (plot_y + plot_height - mouse_y) / plot_height * (y_max - y_min) + y_min;

//         // 检测鼠标是否悬停在红色区域(改进后的逻辑)
//         if (is_dragging || second_x_pos != 0.0f)
//         {
//             float x1 = first_x_pos;
//             float x2 = second_x_pos;
//             float vx1 = plot_x + (x1 - x_min) / (x_max - x_min) * plot_width;
//             float vx2 = plot_x + (x2 - x_min) / (x_max - x_min) * plot_width;

//             // 计算两条线的最小和最大x坐标
//             float min_x = fminf(vx1, vx2);
//             float max_x = fmaxf(vx1, vx2);

//             // 检查鼠标是否在红色区域内(考虑两种绘制顺序)
//             if (mouse_x >= min_x && mouse_x <= max_x && mouse_y >= plot_y && mouse_y <= plot_y + plot_height)
//             {
//                 is_hovering_red_area = true;
//             }
//             else
//             {
//                 is_hovering_red_area = false;
//             }
//         }
//         else
//         {
//             is_hovering_red_area = false;
//         }

//         // 根据悬停状态选择填充颜色
//         NVGcolor fill_color;
//         if (is_hovering_red_area)
//         {
//             fill_color = nvgRGBA(255, 0, 0, 64); // 更亮的红色(更低透明度)
//         }
//         else
//         {
//             fill_color = nvgRGBA(255, 0, 0, 128); // 默认半透明红色
//         }

//         if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
//         {
//             if (!is_dragging)
//             {
//                 // 鼠标按下时，记录第一条垂直线
//                 first_x_pos = mouse_x_in_plot;
//                 is_dragging = true;
//             }
//             else
//             {
//                 // 鼠标拖动时，更新第二条垂直线
//                 second_x_pos = mouse_x_in_plot;
//             }
//         }
//         else
//         {
//             if (is_dragging)
//             {
//                 // 鼠标释放时，固定第二条垂直线
//                 second_x_pos = mouse_x_in_plot;
//                 is_dragging = false;
//             }
//         }

//         // 绘制两条垂直虚线(改进后的逻辑)
//         if (is_dragging || second_x_pos != 0.0f)
//         {
//             // 第一条垂直线(固定)
//             float x1 = first_x_pos;
//             float vx1 = plot_x + (x1 - x_min) / (x_max - x_min) * plot_width;
            
//             // 第二条垂直线(动态)
//             float x2 = second_x_pos;
//             float vx2 = plot_x + (x2 - x_min) / (x_max - x_min) * plot_width;

//             // 计算两条线的最小和最大x坐标
//             float min_x = fminf(vx1, vx2);
//             float max_x = fmaxf(vx1, vx2);

//             // 绘制两条垂直虚线
//             drawDashedLine(vg, vx1, plot_y, vx1, plot_y + plot_height, 5.0f, 5.0f); // 第一条线
//             drawDashedLine(vg, vx2, plot_y, vx2, plot_y + plot_height, 5.0f, 5.0f); // 第二条线

//             // 半透明红色填充(根据悬停状态调整透明度)
//             nvgBeginPath(vg);
//             nvgRect(vg, min_x, plot_y, max_x - min_x, plot_height);
//             nvgFillColor(vg, fill_color);
//             nvgFill(vg);

//             // 水平虚线(两条垂直线之间的中点)
//             float y_mid = plot_y + plot_height / 2;
//             drawDashedLine(vg, min_x, y_mid, max_x, y_mid, 1.0f, 1.0f); // 1px 实线 + 1px 空白

//             // 绘制箭头(简化版，用三角形模拟)
//             float arrow_size = 5.0f;
//             // 左侧箭头(现在可能是原来的第二条线)
//             nvgBeginPath(vg);
//             nvgMoveTo(vg, min_x, y_mid - arrow_size);
//             nvgLineTo(vg, min_x, y_mid + arrow_size);
//             nvgLineTo(vg, min_x + arrow_size, y_mid);
//             nvgClosePath(vg);
//             nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
//             nvgFill(vg);

//             // 右侧箭头(现在可能是原来的第一条线)
//             nvgBeginPath(vg);
//             nvgMoveTo(vg, max_x, y_mid - arrow_size);
//             nvgLineTo(vg, max_x, y_mid + arrow_size);
//             nvgLineTo(vg, max_x - arrow_size, y_mid);
//             nvgClosePath(vg);
//             nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
//             nvgFill(vg);

//             // 显示距离值(使用绝对值确保正确)
//             float distance = fabsf(x2 - x1);
//             char distance_text[32];
//             snprintf(distance_text, sizeof(distance_text), "%.2f", distance);
//             nvgFontSize(vg, 12.0f);
//             nvgFontFace(vg, "sans");
//             nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
//             nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
//             nvgText(vg, (min_x + max_x) / 2, y_mid, distance_text, NULL);
//         }

//         // 结束 NanoVG 帧
//         nvgEndFrame(vg);

//         // 交换缓冲区
//         glfwSwapBuffers(window);
//     }

//     // 清理资源
//     nvgDeleteGL3(vg);
//     glfwDestroyWindow(window);
//     glfwTerminate();

//     return 0;
// }



#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <nanovg.h>
#define NANOVG_GL3_IMPLEMENTATION
#include <nanovg_gl.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
using namespace std;

// 全局变量
static bool is_dragging = false;
static float first_x_pos = 0.0f;  // 第一条垂直线 x 坐标
static float second_x_pos = 0.0f; // 第二条垂直线 x 坐标

// 鼠标是否悬停在红色区域
static bool is_hovering_red_area = false;

// 动态波形数据
float* xs = nullptr;  // x坐标数组
float* ys = nullptr;  // y坐标数组
int point_count = 100; // 数据点数量
float amplitude = 1.0f; // 振幅
float frequency = 1.0f; // 频率
float timevar = 0.0f;      // 时间变量

// 生成动态正弦波数据（带时间变化）
void generateDynamicSineWave(float *xs, float *ys, int count, float amplitude, float frequency, float time)
{
    for (int i = 0; i < count; ++i)
    {
        xs[i] = i * 0.1f; // x坐标固定步长
        // 添加时间变量使波形动态变化
        ys[i] = amplitude * sin(frequency * xs[i] + time);
    }
}

// 手动绘制虚线(替代 nvgStrokeDashArray)
void drawDashedLine(NVGcontext *vg, float x1, float y1, float x2, float y2, float dashLength, float gapLength)
{
    float dx = x2 - x1;
    float dy = y2 - y1;
    float length = sqrtf(dx * dx + dy * dy);
    if (length == 0) return; // 避免除以零
    float dashCount = length / (dashLength + gapLength);

    nvgBeginPath(vg);
    for (float i = 0; i < dashCount; i++)
    {
        float start = i * (dashLength + gapLength);
        float end = start + dashLength;
        if (end > length)
            end = length;

        float sx = x1 + (dx / length) * start;
        float sy = y1 + (dy / length) * start;
        float ex = x1 + (dx / length) * end;
        float ey = y1 + (dy / length) * end;

        nvgMoveTo(vg, sx, sy);
        nvgLineTo(vg, ex, ey);
    }
    nvgStrokeColor(vg, nvgRGBA(255, 255, 255, 255));
    nvgStrokeWidth(vg, 1.0f);
    nvgStroke(vg);
}

// 绘制刻度线和标签
void drawAxisTicks(NVGcontext* vg, float x, float y, float length, int count, float step, bool isVertical)
{
    nvgStrokeColor(vg, nvgRGBA(100, 100, 100, 255));
    nvgStrokeWidth(vg, 1.0f);
    
    float start = isVertical ? y - length : x - length;
    float end = isVertical ? y + length : x + length;
    
    // 绘制刻度线
    for (int i = 0; i <= count; i++)
    {
        float pos = isVertical ? y - (i * step) : x + (i * step);
        if (isVertical)
        {
            nvgBeginPath(vg);
            nvgMoveTo(vg, x - 5, pos);
            nvgLineTo(vg, x + 5, pos);
            nvgStroke(vg);
            
            // 绘制刻度值
            char label[16];
            snprintf(label, sizeof(label), "%.1f", i * step);
            nvgFontSize(vg, 10.0f);
            nvgFontFace(vg, "sans");
            nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
            nvgFillColor(vg, nvgRGBA(200, 200, 200, 255));
            nvgText(vg, x - 10, pos, label, NULL);
        }
        else
        {
            nvgBeginPath(vg);
            nvgMoveTo(vg, pos, y - 5);
            nvgLineTo(vg, pos, y + 5);
            nvgStroke(vg);
            
            // 绘制刻度值
            char label[16];
            snprintf(label, sizeof(label), "%.1f", i * step);
            nvgFontSize(vg, 10.0f);
            nvgFontFace(vg, "sans");
            nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
            nvgFillColor(vg, nvgRGBA(200, 200, 200, 255));
            nvgText(vg, pos, y + 10, label, NULL);
        }
    }
}

// 主函数
int main()
{
    // 初始化 GLFW
    if (!glfwInit())
    {
        fprintf(stderr, "Failed to initialize GLFW\n");
        return -1;
    }

    // 创建窗口
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    GLFWwindow *window = glfwCreateWindow(800, 600, "Dynamic NanoVG Waveform with Dragging Lines", NULL, NULL);
    if (!window)
    {
        fprintf(stderr, "Failed to create GLFW window\n");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    // 初始化 GLEW
    if (glewInit() != GLEW_OK)
    {
        std::cerr << "Failed to initialize GLEW" << std::endl;
        glfwTerminate();
        return -1;
    }
    // 初始化 NanoVG
    NVGcontext *vg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES);
    if (vg == NULL)
    {
        fprintf(stderr, "Could not init nanovg.\n");
        return -1;
    }

    // 分配内存给波形数据
    xs = new float[point_count];
    ys = new float[point_count];
    
    // 初始生成波形数据
    generateDynamicSineWave(xs, ys, point_count, amplitude, frequency, timevar);
    
    // 加载字体
    int fontNormal = nvgCreateFont(vg, "sans", "C:/Users/free/Downloads/OpenGLProject/OffScreen/Roboto-Bold.ttf");
    if (fontNormal == -1)
    {
        printf("Error: Could not load font 'Roboto-Bold.ttf'\n");
        // 处理错误(如退出程序或使用备用字体)
    }

    // 主循环
    double last_time = glfwGetTime();
    while (!glfwWindowShouldClose(window))
    {
        // 计算时间增量
        double current_time = glfwGetTime();
        float delta_time = (float)(current_time - last_time);
        last_time = current_time;
        
        // 更新时间变量（用于波形动画）
        timevar += delta_time * 0.5f; // 调整这个系数可以改变动画速度

        // 处理输入
        glfwPollEvents();

        // 获取窗口尺寸
        int fb_width, fb_height;   // 帧缓冲区大小(像素)
        int win_width, win_height; // 窗口大小(逻辑像素)

        glfwGetFramebufferSize(window, &fb_width, &fb_height); // 获取帧缓冲区大小
        glfwGetWindowSize(window, &win_width, &win_height);    // 获取窗口大小

        float pixel_ratio = (float)fb_width / (float)win_width; // 计算像素比例

        // 开始 NanoVG 帧
        nvgBeginFrame(vg, win_width, win_height, pixel_ratio);

        // 绘制背景
        nvgBeginPath(vg);
        nvgRect(vg, 0, 0, win_width, win_height);
        nvgFillColor(vg, nvgRGBA(30, 30, 30, 255));
        nvgFill(vg);

        // 绘制绘图区域(假设绘图区域占窗口的80%)
        float plot_margin = 50.0f;
        float plot_width = win_width - 2 * plot_margin;
        float plot_height = win_height - 2 * plot_margin;
        float plot_x = plot_margin;
        float plot_y = plot_margin;

        // 绘制绘图区域背景
        nvgBeginPath(vg);
        nvgRect(vg, plot_x, plot_y, plot_width, plot_height);
        nvgFillColor(vg, nvgRGBA(40, 40, 40, 255));
        nvgFill(vg);

        // 计算正弦波的绘制范围
        float x_min = 0.0f;
        float x_max = point_count * 0.1f;
        float y_min = -1.5f;
        float y_max = 1.5f;

        // 绘制坐标轴
        nvgBeginPath(vg);
        nvgMoveTo(vg, plot_x, plot_y + plot_height / 2);
        nvgLineTo(vg, plot_x + plot_width, plot_y + plot_height / 2);
        nvgMoveTo(vg, plot_x + plot_width / 2, plot_y);
        nvgLineTo(vg, plot_x + plot_width / 2, plot_y + plot_height);
        nvgStrokeColor(vg, nvgRGBA(100, 100, 100, 255));
        nvgStrokeWidth(vg, 1.0f);
        nvgStroke(vg);

        // 绘制X轴刻度
        int x_tick_count = 10;
        float x_step = (x_max - x_min) / x_tick_count;
        drawAxisTicks(vg, plot_x + plot_width / 2, plot_y + plot_height, 5.0f, x_tick_count, x_step, true);

        // 绘制Y轴刻度
        int y_tick_count = 10;
        float y_step = (y_max - y_min) / y_tick_count;
        drawAxisTicks(vg, plot_x, plot_y + plot_height / 2, 5.0f, y_tick_count, y_step, false);

        // 动态生成波形数据
        generateDynamicSineWave(xs, ys, point_count, amplitude, frequency, timevar);

        // 绘制正弦波（限制在绘图区域内）
        nvgBeginPath(vg);
        for (int i = 0; i < point_count; ++i)
        {
            // 计算绘图坐标
            float x = plot_x + (xs[i] - x_min) / (x_max - x_min) * plot_width;
            float y = plot_y + plot_height / 2 - (ys[i] - y_min) / (y_max - y_min) * plot_height;
            
            // 确保点在绘图区域内
            x = fmaxf(plot_x, fminf(x, plot_x + plot_width));
            y = fmaxf(plot_y, fminf(y, plot_y + plot_height));
            
            if (i == 0)
            {
                nvgMoveTo(vg, x, y);
            }
            else
            {
                nvgLineTo(vg, x, y);
            }
        }
        nvgStrokeColor(vg, nvgRGBA(255, 255, 255, 255));
        nvgStrokeWidth(vg, 2.0f);
        nvgStroke(vg);

        // 鼠标交互逻辑
        double mouse_x, mouse_y;
        glfwGetCursorPos(window, &mouse_x, &mouse_y);
        float mouse_x_in_plot = (mouse_x - plot_x) / plot_width * (x_max - x_min) + x_min;
        float mouse_y_in_plot = (plot_y + plot_height - mouse_y) / plot_height * (y_max - y_min) + y_min;

        // 检测鼠标是否悬停在红色区域(改进后的逻辑)
        if (is_dragging || second_x_pos != 0.0f)
        {
            float x1 = first_x_pos;
            float x2 = second_x_pos;
            float vx1 = plot_x + (x1 - x_min) / (x_max - x_min) * plot_width;
            float vx2 = plot_x + (x2 - x_min) / (x_max - x_min) * plot_width;

            // 计算两条线的最小和最大x坐标
            float min_x = fminf(vx1, vx2);
            float max_x = fmaxf(vx1, vx2);

            // 检查鼠标是否在红色区域内(考虑两种绘制顺序)
            if (mouse_x >= min_x && mouse_x <= max_x && mouse_y >= plot_y && mouse_y <= plot_y + plot_height)
            {
                is_hovering_red_area = true;
            }
            else
            {
                is_hovering_red_area = false;
            }
        }
        else
        {
            is_hovering_red_area = false;
        }

        // 根据悬停状态选择填充颜色
        NVGcolor fill_color;
        if (is_hovering_red_area)
        {
            fill_color = nvgRGBA(255, 0, 0, 64); // 更亮的红色(更低透明度)
        }
        else
        {
            fill_color = nvgRGBA(255, 0, 0, 128); // 默认半透明红色
        }

        if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
        {
            if (!is_dragging)
            {
                // 鼠标按下时，记录第一条垂直线
                first_x_pos = mouse_x_in_plot;
                is_dragging = true;
            }
            else
            {
                // 鼠标拖动时，更新第二条垂直线
                second_x_pos = mouse_x_in_plot;
            }
        }
        else
        {
            if (is_dragging)
            {
                // 鼠标释放时，固定第二条垂直线
                second_x_pos = mouse_x_in_plot;
                is_dragging = false;
            }
        }

        // 绘制两条垂直虚线(改进后的逻辑)
        if (is_dragging || second_x_pos != 0.0f)
        {
            // 第一条垂直线(固定)
            float x1 = first_x_pos;
            float vx1 = plot_x + (x1 - x_min) / (x_max - x_min) * plot_width;
            
            // 第二条垂直线(动态)
            float x2 = second_x_pos;
            float vx2 = plot_x + (x2 - x_min) / (x_max - x_min) * plot_width;

            // 计算两条线的最小和最大x坐标
            float min_x = fminf(vx1, vx2);
            float max_x = fmaxf(vx1, vx2);

            // 绘制两条垂直虚线
            drawDashedLine(vg, vx1, plot_y, vx1, plot_y + plot_height, 5.0f, 5.0f); // 第一条线
            drawDashedLine(vg, vx2, plot_y, vx2, plot_y + plot_height, 5.0f, 5.0f); // 第二条线

            // 半透明红色填充(根据悬停状态调整透明度)
            nvgBeginPath(vg);
            nvgRect(vg, min_x, plot_y, max_x - min_x, plot_height);
            nvgFillColor(vg, fill_color);
            nvgFill(vg);

            // 水平虚线(两条垂直线之间的中点)
            float y_mid = plot_y + plot_height / 2;
            drawDashedLine(vg, min_x, y_mid, max_x, y_mid, 1.0f, 1.0f); // 1px 实线 + 1px 空白

            // 绘制箭头(简化版，用三角形模拟)
            float arrow_size = 5.0f;
            // 左侧箭头(现在可能是原来的第二条线)
            nvgBeginPath(vg);
            nvgMoveTo(vg, min_x, y_mid - arrow_size);
            nvgLineTo(vg, min_x, y_mid + arrow_size);
            nvgLineTo(vg, min_x + arrow_size, y_mid);
            nvgClosePath(vg);
            nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
            nvgFill(vg);

            // 右侧箭头(现在可能是原来的第一条线)
            nvgBeginPath(vg);
            nvgMoveTo(vg, max_x, y_mid - arrow_size);
            nvgLineTo(vg, max_x, y_mid + arrow_size);
            nvgLineTo(vg, max_x - arrow_size, y_mid);
            nvgClosePath(vg);
            nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
            nvgFill(vg);

            // 显示距离值(使用绝对值确保正确)
            float distance = fabsf(x2 - x1);
            char distance_text[32];
            snprintf(distance_text, sizeof(distance_text), "%.2f", distance);
            nvgFontSize(vg, 12.0f);
            nvgFontFace(vg, "sans");
            nvgTextAlign(vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
            nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
            nvgText(vg, (min_x + max_x) / 2, y_mid, distance_text, NULL);
        }

        // 结束 NanoVG 帧
        nvgEndFrame(vg);

        // 交换缓冲区
        glfwSwapBuffers(window);
    }

    // 清理资源
    delete[] xs;
    delete[] ys;
    nvgDeleteGL3(vg);
    glfwDestroyWindow(window);
    glfwTerminate();

    return 0;
}